import { Controller } from "../../mvc/core/Controller";
import { MarryWeddingView } from "../view/marry/MarryWeddingView";
import { MarryDivorceIconView } from "../view/marry/MarryDivorceIconView";
import { Dispatcher } from "../../mvc/core/Dispatcher";
import { EventName } from "../mvc/EventName";
import { NetDispatcher } from "../../mvc/core/NetDispatcher";
import { ServerCommand } from "../mvc/ServerCommand";
import { DataEvent } from "../events/DataEvent";
import { SPublicMiniPlayer } from "../../../Message/Public/SPublicMiniPlayer";
import { FriendInfo } from "../model/FriendInfo";
import { Alert } from "../../../com/mui/controls/Alert";
import { GameProxy } from "../mvc/GameProxy";
import { ParamsConst } from "../../common/global/ParamsConst";
import { Global } from "../../../com/gengine/global/Global";
import { MsgManager } from "../manager/MsgManager";
import { Language } from "../../../extend/language/Language";
import { EMarryStatus } from "../../../Message/Game/EMarryStatus";
import { EFriendFlag } from "../../../Message/Game/EFriendFlag";
import { EWeddingStatus } from "../../../Message/Game/EWeddingStatus";
import { ThingUtil } from "../scene/layer/utils/ThingUtil";
import { NpcEffectRule } from "../rules/NpcEffectRule";
import { BookingSceneData } from "../view/marry/defin/BookingSceneData";
import { SWedding } from "../../../Message/Public/SWedding";
import { MarryBlessData } from "../view/marry/defin/MarryBlessData";
import { PageData } from "../view/arena/ArenaData/PageData";
import { ItemData } from "../resource/info/ItemData";
import { ItemsUtil } from "../view/shortcuts/item/ItemsUtil";
import { SMarryApply } from "../../../Message/Public/SMarryApply";
import { EMarryReplyResult } from "../../../Message/Game/EMarryReplyResult";
import { TimerAlertWin } from "../view/common/alertwins/TimerAlertWin";
import { SMarryReply } from "../../../Message/Public/SMarryReply";
import { RolePlayer } from "../scene/player/entity/RolePlayer";
import { SecTimer } from "../../../com/gengine/core/frame/SecTimer";
import { TimerType } from "../../../com/gengine/core/frame/TimerType";
import { MonsterPlayer } from "../scene/player/entity/MonsterPlayer";
import { EBossType } from "../../../Message/Public/EBossType";
import { FWManager } from "../../../extend/flash/fireworks/FWManager";
import { FireWorkType } from "../../../extend/flash/fireworks/FireWorkType";
import { FirePlayType } from "../../../extend/flash/fireworks/FirePlayType";
import { ClockManager } from "../manager/ClockManager";
import { GameConst } from "../../component/gconst/GameConst";
import { SMarryGuestInfos } from "../../../Message/Public/SMarryGuestInfos";
import { SMarryCeremony } from "../../../Message/Public/SMarryCeremony";
import { Game } from "../Game";
import { Cache } from "../cache/Cache";
import { EMarryWeddingType } from "../../../Message/Game/EMarryWeddingType";
import { FlowerManager } from "../../../extend/flash/flower/FlowerManager";
import { StaticResUrl } from "../resource/StaticResUrl";
import { ESex } from "../../../Message/Public/ESex";
import { CeremonySprite } from "../scene/player/item/CeremonySprite";
import { GameMapUtil } from "../scene/map/GameMapUtil";
import { MarryFlowerManager } from "../../../extend/flash/flower/marry/MarryFlowerManager";
import { MarryFlowerType } from "../../../extend/flash/flower/marry/MarryFlowerType";
import { MarrySceneFire } from "../view/marry/flower/MarrySceneFire";
import { MarryHistoryData } from "../view/marry/defin/MarryHistoryData";
import { SWeddingGuestInfo } from "../../../Message/Public/SWeddingGuestInfo";
import { SWeddingApplicators } from "../../../Message/Public/SWeddingApplicators";
import { SWeddingStatus } from "../../../Message/Public/SWeddingStatus";
import { AIManager } from "../scene/ai/AIManager";
import { ENpcEffect } from "../../../Message/Public/ENpcEffect";
import { SWeddingFirework } from "../../../Message/Public/SWeddingFirework";
import { SPlayerMarry } from "../../../Message/Public/SPlayerMarry";
import { SActiveToClient } from "../../../Message/Public/SActiveToClient";
import { MarryBookingScene } from "../view/marry/MarryBookingScene";
import { MarryInviteGuests } from "../view/marry/MarryInviteGuests";
import { MarryManageWindow } from "../view/marry/MarryManageWindow";
import { MarryDivorce } from "../view/marry/MarryDivorce";
import { MarryBlessWindow } from "../view/marry/MarryBlessWindow";
import { MarryMsgWindow } from "../view/marry/MarryMsgWindow";
import { MarryParadeIconView } from "../view/marry/MarryParadeIconView";
import { MarryCelebrationIconView } from "../view/marry/MarryCelebrationIconView";
import { MarryProcessIconView } from "../view/marry/MarryProcessIconView";
import { MarryRegister } from "../view/marry/MarryRegister";
import { MarryBookingSuccessWindow } from "../view/marry/MarryBookingSuccessWindow";
import { MarryLog } from "../view/marry/MarryLog";
import { MarryProcess } from "../view/marry/MarryProcess";
import { _EMarryReplyResultAccept } from "../../../EMarryReplyResult/_EMarryReplyResultAccept";
type int = number;
//class MarryController
    
    export  class MarryController extends Controller
    {
        constructor()
        {
            
            super();this.aryPoint = new Array<any>([]);
            return;
        }

        /* internal  */get marryWeddingView(): MarryWeddingView
        {
            if (!this._marryWeddingView) 
            {
                this._marryWeddingView = new MarryWeddingView();
            }
            return this._marryWeddingView;
        }

        /* internal  */get marryDivorceIconView(): MarryDivorceIconView
        {
            if (!this._marryDivorceIconView) 
            {
                this._marryDivorceIconView = new MarryDivorceIconView();
            }
            return this._marryDivorceIconView;
        }

        protected /* override */ initServer(): void
        {
            Dispatcher.addEventListener(EventName.MarryNPCApplyMarry, this.onMarryNPCApplyMarry);
            Dispatcher.addEventListener(EventName.MarryNPCBookingScene, this.onMarryNPCBookingScene);
            Dispatcher.addEventListener(EventName.MarryNPCInviteGuests, this.onMarryNPCInviteGuests);
            Dispatcher.addEventListener(EventName.MarryNPCCelebration, this.onMarryNPCCelebration);
            Dispatcher.addEventListener(EventName.MarryNPCParade, this.onMarryMarryNPCParade);
            Dispatcher.addEventListener(EventName.MarryNPCDivorce, this.onMarryNPCDivorce);
            Dispatcher.addEventListener(EventName.MarryNPCMarryLog, this.onMarryNPCLog);
            Dispatcher.addEventListener(EventName.MarryNPCMarryProcess, this.onMarryProcess);
            Dispatcher.addEventListener(EventName.MarryShowBookingWindow, this.onShowBookingWindow);
            Dispatcher.addEventListener(EventName.MarryGetBookHours, this.onGetBookHours);
            Dispatcher.addEventListener(EventName.MarryBookingHour, this.onBookingHour);
            Dispatcher.addEventListener(EventName.MarryShowBlessWindow, this.onMarryShowBlessWindow);
            Dispatcher.addEventListener(EventName.MarryShowMarryMsgWindow, this.onMarryShowMarryMsgWindow);
            Dispatcher.addEventListener(EventName.MarryShowManageWindow, this.onMarryShowManageWindow);
            Dispatcher.addEventListener(EventName.MarryEnterMarryScene, this.onEnterMarryScene);
            Dispatcher.addEventListener(EventName.MarryGetInvitedGuest, this.onGetInvitedGuest);
            Dispatcher.addEventListener(EventName.MarryFriendInviteAddToRight, this.onMarryFriendInviteAddToRight);
            Dispatcher.addEventListener(EventName.MarryFriendCancelInvite, this.onMarryFriendCancelInvite);
            Dispatcher.addEventListener(EventName.MarryInviteNow, this.onInviteNow);
            Dispatcher.addEventListener(EventName.MarryGetSceneGuestList, this.onGetSceneGuestList);
            Dispatcher.addEventListener(EventName.MarryGetBlessHistory, this.onGetBlessHistory);
            Dispatcher.addEventListener(EventName.MarryBlessSend, this.onMarryBlessSend);
            Dispatcher.addEventListener(EventName.MarryGetLog, this.onMarryGetLog);
            Dispatcher.addEventListener(EventName.MarryPackUseInvitation, this.onMarryPackUseInvitation);
            Dispatcher.addEventListener(EventName.MarryAgreeGuestApply, this.onMarryAgreeGuestApply);
            Dispatcher.addEventListener(EventName.MarryRefuseGuestApply, this.onMarryRefuseGuestApply);
            Dispatcher.addEventListener(EventName.MarryAskForInvite, this.onMarryAskForInvite);
            Dispatcher.addEventListener(EventName.MarryGetGuestApply, this.onMarryGetGuestApply);
            Dispatcher.addEventListener(EventName.MarrySearchPlayerInvite, this.onMarrySearchPlayerInvite);
            Dispatcher.addEventListener(EventName.MarryStartWedding, this.onMarryStartWedding);
            Dispatcher.addEventListener(EventName.MarryWeddingRequestShopData, this.onMarryWeddingRequestShopData);
            Dispatcher.addEventListener(EventName.MarryWholeReplyCardApplicators, this.onMarryWholeReplyCardApplicators);
            Dispatcher.addEventListener(EventName.MarryDivorceMarryConfirm, this.onMarryDivorceMarryConfirm);
            Dispatcher.addEventListener(EventName.MarryReplyDivorce, this.onMarryReplyDivorce);
            Dispatcher.addEventListener(EventName.MarryAutoUseInvite, this.onMarryAutoUseInvite);
            NetDispatcher.addCmdListener(ServerCommand.MarryApplyCommand, this.onMarryApplyCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryReplyCommand, this.onMarryReplyCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryRegistSuccessCommand, this.onRegistSuccessHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryBookHoursCommand, this.onBookHoursHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryBookingSceneSuccess, this.onBookingSceneSuccessHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryInvitedGuestUpdate, this.onInvitedGuestUpdate);
            NetDispatcher.addCmdListener(ServerCommand.MarryBlessHistoryUpdate, this.onBlessHistoryHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryParadeStartCommand, this.onParadeStartCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryParadeEndCommand, this.onParadeEndCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryCelebrationStartCommand, this.onCelebrationStartCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryCelebrationEndCommand, this.onCelebrationEndCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryGuestInfosCommand, this.onGuestInfosCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryCeremonyCommand, this.onCeremonyHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryEndCeremonyCommand, this.onMarryEndCeremonyHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryHistoryDataCommand, this.onMarryHistoryDataHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryInviteInfoCommand, this.onMarryInviteInfoHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryWeddingApplicatorsUpdate, this.onMarryWeddingApplicatorsHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryWeddingCanEnterCommand, this.onWeddingCanEnterHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryWeddingStatusCommand, this.onMarryWeddingStatusHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarrySearchPlayerSuccess, this.onMarrySearchPlayerSuccessHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryEnterWedding, this.onMarryEnterWeddingHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryLeaveWedding, this.onMarryLeaveWeddingHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryCeremoneyHadStartCommand, this.onMarryCeremoneyHadStartHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryWeddingFireWorkCommand, this.onMarryWeddingFireWorkHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryPlayerMarryUpdateCommand, this.onMarryPlayerMarryUpdateHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryApplyDivorceSuccess, this.onMarryApplyDivorceSuccessHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryHasWeddingApplyCommand, this.onMarryHasWeddingApplyHandler);
            NetDispatcher.addCmdListener(ServerCommand.MarryPackInvitesUpdate, this.onMarryPackInvitesUpdateHandler);
            NetDispatcher.addCmdListener(ServerCommand.FriendListUpdate, this.onFriendListUpdate);
            NetDispatcher.addCmdListener(ServerCommand.FriendAdd, this.onFriendListUpdate);
            NetDispatcher.addCmdListener(ServerCommand.FriendUpdate, this.onFriendListUpdate);
            NetDispatcher.addCmdListener(ServerCommand.ActiveTypeMarrySameSex, this.onActiveTypeMarrySameSexHandler);
            return;
        }

        /* internal  */onMarryNPCApplyMarry(arg1: DataEvent): void
        {
            var e: DataEvent;
            var isOverLevel: Boolean;
            var otherPlayer: SPublicMiniPlayer;
            var i: int;
            var friendInfo: FriendInfo;
            var onClose: Function;
            var player: SPublicMiniPlayer;

            var loc1;
            otherPlayer = null;
            onClose = null;
            player = null;
            e = arg1;
            onClose = (arg1: int): void
            {
                if (arg1 == Alert.OK) 
                {
                    GameProxy.marry.apply(otherPlayer.entityId.id);
                }
                return;
            }
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (cache.marry.playerMarry && !(cache.marry.playerMarry.status == EMarryStatus._EMarryStatusNo)) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43507));
                return;
            }
            if (cache.group.players.length > 2) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43508));
                return;
            }
            if (cache.group.players.length < 2) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43509));
                return;
            }
            if (!cache.group.isCaptain) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43510));
                return;
            }
            isOverLevel = true;
            i = 0;
            while (i < cache.group.players.length) 
            {
                player = cache.group.players[i];
                if (player.level < 40) 
                {
                    isOverLevel = false;
                }
                if (player.name != cache.role.entityInfo.name) 
                {
                    otherPlayer = player;
                }
                ++i;
            }
            if (!isOverLevel) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43512));
                return;
            }
            if (otherPlayer.online == false) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43513));
                return;
            }
            friendInfo = cache.friend.getFriendInfoByPlayerName(otherPlayer.name, EFriendFlag._EFriendFlagFriend);
            if (!friendInfo) 
            {
                MsgManager.showRollTipsMsg(Language.getStringByParam(43514, otherPlayer.name));
                return;
            }
            if (friendInfo.intimate < 8000) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43515));
                return;
            }
            Alert.show(Language.getString(43516), null, Alert.OK | Alert.CANCEL, null, onClose);
            return;
        }

        /* internal  */onMarryNPCBookingScene(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (!cache.marry.playerMarry || cache.marry.playerMarry.status == EMarryStatus._EMarryStatusNo) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43517));
                return;
            }
            if (cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusSuccess) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43518));
                return;
            }
            if (cache.marry.playerMarry && (cache.marry.playerMarry.status == EMarryStatus._EMarryStatusApply || cache.marry.playerMarry.status == EMarryStatus._EMarryStatusBeApply)) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43644));
                return;
            }
            this.marryBookingScene.show();
            return;
        }

        /* internal  */onMarryNPCInviteGuests(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (!cache.marry.playerMarry || cache.marry.playerMarry.status == EMarryStatus._EMarryStatusNo) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43517));
                return;
            }
            if (cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusNotBook || cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusCanBook || cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusServerDown) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43519));
                return;
            }
            if (cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusSuccess) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43518));
                return;
            }
            this.marryInviteGuests.show();
            return;
        }

        /* internal  */onMarryNPCCelebration(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (!cache.marry.isInCelebration) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43520));
            }
            if (cache.marry.celebrationWedding) 
            {
                GameProxy.marry.enterWedding(cache.marry.celebrationWedding.recordId);
            }
            return;
        }

        /* internal  */onMarryMarryNPCParade(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (!cache.marry.playerMarry || cache.marry.playerMarry.status == EMarryStatus._EMarryStatusNo) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43517));
                return;
            }
            if (cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusNotBook || cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusCanBook || cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusServerDown) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43519));
                return;
            }
            if (cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusWeddingCar || cache.marry.weddingStatus.status == EWeddingStatus._EWeddingStatusSuccess) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43521));
                return;
            }
            if (ThingUtil.entityUtil.getEntity(cache.marry.playerMarry.mate.entityId) == null) 
            {
                MsgManager.showRollTipsMsg(Language.getStringByParam(43666, cache.marry.playerMarry.mate.name));
                return;
            }
            GameProxy.marry.startWeddingCar();
            return;
        }

        /* internal  */onMarryNPCDivorce(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            if (!cache.marry.playerMarry || cache.marry.playerMarry.status == EMarryStatus._EMarryStatusNo) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43517));
                return;
            }
            this.marryDivorce.show();
            NpcEffectRule.registDialogEffectWindow(this.marryDivorce);
            return;
        }

        /* internal  */onMarryNPCLog(arg1: DataEvent): void
        {
            if (!ParamsConst.instance.isOpenMarry && !Global.isDebugModle) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43506));
                return;
            }
            this.marryLogWindow.show();
            return;
        }

        /* internal  */onMarryProcess(arg1: DataEvent): void
        {
            this.marryProcessWindow.show();
            return;
        }

        /* internal  */onShowBookingWindow(arg1: DataEvent): void
        {
            this.marryBookingScene.show();
            return;
        }

        /* internal  */onGetBookHours(arg1: DataEvent): void
        {
            GameProxy.marry.getBookHours();
            return;
        }

        /* internal  */onBookingHour(arg1: DataEvent): void
        {
            var loc1=arg1.data as BookingSceneData;
            GameProxy.marry.bookWedding(loc1.celebrationType, loc1.hour);
            return;
        }

        /* internal  */onMarryShowBlessWindow(arg1: DataEvent): void
        {
            var loc1=arg1.data as SWedding;
            this.marryBlessWindow.updateData(loc1);
            this.marryBlessWindow.show();
            return;
        }

        /* internal  */onMarryShowMarryMsgWindow(arg1: DataEvent): void
        {
            var loc1=arg1.data as SWedding;
            this.marryMsgWindow.updateWedding(loc1);
            this.marryMsgWindow.show();
            return;
        }

        /* internal  */onMarryShowManageWindow(arg1: DataEvent): void
        {
            this.marryManageWindow.show();
            return;
        }

        /* internal  */onEnterMarryScene(arg1: DataEvent): void
        {
            var loc1=arg1.data as SWedding;
            if (loc1) 
            {
                GameProxy.marry.enterWedding(loc1.recordId);
            }
            return;
        }

        /* internal  */onGetInvitedGuest(arg1: DataEvent): void
        {
            GameProxy.marry.getInvitedGuest();
            return;
        }

        /* internal  */onMarryFriendInviteAddToRight(arg1: DataEvent): void
        {
            this.marryInviteGuests.addPeople(arg1.data as string);
            return;
        }

        /* internal  */onMarryFriendCancelInvite(arg1: DataEvent): void
        {
            this.marryInviteGuests.cancelPeople(arg1.data as string);
            return;
        }

        /* internal  */onInviteNow(arg1: DataEvent): void
        {
            var loc1=arg1.data as Array<any>;
            GameProxy.marry.inviteGuest(loc1);
            return;
        }

        /* internal  */onGetSceneGuestList(arg1: DataEvent): void
        {
            if (cache.marry.celebrationWedding) 
            {
                GameProxy.marry.getWeddingGuest(cache.marry.celebrationWedding.recordId);
            }
            return;
        }

        /* internal  */onGetBlessHistory(arg1: DataEvent): void
        {
            var loc1=arg1.data as SWedding;
            if (loc1) 
            {
                GameProxy.marry.getBlessHistory(loc1.recordId);
            }
            return;
        }

        /* internal  */onMarryBlessSend(arg1: DataEvent): void
        {
            var loc2=0;
            var loc1=arg1.data as MarryBlessData;
            if (loc1.type == MarryBlessData.Coin) 
            {
                loc2 = int(loc1.data);
                if (cache.login.loginGame.money.coin < loc2) 
                {
                    MsgManager.showRollTipsMsg(Language.getString(43523));
                    return;
                }
                GameProxy.marry.sendMoney(loc1.miniPlayer.name, loc2);
            }
            if (loc1.type == MarryBlessData.Flower) 
            {
                GameProxy.marry.sendFlower(loc1.miniPlayer.name, loc1.data);
            }
            return;
        }

        /* internal  */onMarryGetLog(arg1: DataEvent): void
        {
            var loc1=arg1.data as PageData;
            GameProxy.marry.getMarryHistory(loc1.pageNum, loc1.pageSize);
            return;
        }

        /* internal  */onMarryPackUseInvitation(arg1: DataEvent): void
        {
            var loc1=arg1.data as ItemData;
            GameProxy.marry.useInviteCard(loc1.uid);
            return;
        }

        /* internal  */onMarryAgreeGuestApply(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            GameProxy.marry.replyCardApplicators(loc1.name, true);
            return;
        }

        /* internal  */onMarryRefuseGuestApply(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            GameProxy.marry.replyCardApplicators(loc1.name, false);
            return;
        }

        /* internal  */onMarryAskForInvite(arg1: DataEvent): void
        {
            var loc1=arg1.data as SWedding;
            GameProxy.marry.applyInviteCard(loc1.recordId);
            return;
        }

        /* internal  */onMarryGetGuestApply(arg1: DataEvent): void
        {
            GameProxy.marry.getCardApplicators();
            return;
        }

        /* internal  */onMarrySearchPlayerInvite(arg1: DataEvent): void
        {
            GameProxy.marry.searchPlayer(arg1.data as string);
            return;
        }

        /* internal  */onMarryStartWedding(arg1: DataEvent): void
        {
            GameProxy.marry.startCeremony();
            return;
        }

        /* internal  */onMarryWeddingRequestShopData(arg1: DataEvent): void
        {
            GameProxy.marry.getWeddingNpcShop();
            this.isRequestWeddingShop = true;
            return;
        }

        /* internal  */onMarryWholeReplyCardApplicators(arg1: DataEvent): void
        {
            var loc1=Boolean(arg1.data);
            GameProxy.marry.wholeReplyCardApplicators(loc1);
            return;
        }

        /* internal  */onMarryDivorceMarryConfirm(arg1: DataEvent): void
        {
            var loc1=Boolean(arg1.data);
            GameProxy.marry.applyDivorce(loc1);
            return;
        }

        /* internal  */onMarryReplyDivorce(arg1: DataEvent): void
        {
            var loc1=cache.marry.weddingStatus;
            if (loc1 && (loc1.status == EWeddingStatus._EWeddingStatusHadBooked || loc1.status == EWeddingStatus._EWeddingStatusWeddingCar || cache.marry.isInCelebration && cache.marry.isSelfWedding())) 
            {
                MsgManager.showRollTipsMsg(Language.getString(43645));
            }
            var loc2=Boolean(arg1.data);
            GameProxy.marry.replyDivorce(loc2);
            return;
        }

        /* internal  */onMarryAutoUseInvite(arg1: DataEvent): void
        {
            var loc3=null;
            var loc1=int(arg1.data);
            var loc2=cache.pack.backPackCache.getItemsByJudge(ItemsUtil.isInvitation);
            if (loc2.length > 0) 
            {
                loc3 = loc2[0] as ItemData;
                loc1 = Math.min(loc1, loc3.itemAmount);
                GameProxy.marry.autoUseInvite(loc3.uid, loc1);
            }
            return;
        }

        /* internal  */onMarryApplyCommandHandler(arg1: SMarryApply): void
        {
            var marryApply: SMarryApply;
            var onChoose: Function;

            var loc1;
            onChoose = null;
            marryApply = arg1;
            onChoose = (arg1: int): void
            {
                var loc1=arg1 != Alert.OK ? EMarryReplyResult._EMarryReplyResultReject : _EMarryReplyResultAccept;
                GameProxy.marry.reply(marryApply.applicator.entityId.id, loc1);
                return;
            }
            Alert.mode = Alert.Mode_NoneNotModal;
            Alert.alertWinRenderer = TimerAlertWin;
            Alert.okLabel = Language.getString(43524);
            Alert.calcelLabel = Language.getString(43525);
            Alert.timerOut = 20;
            Alert.timerNO = true;
            Alert.show(Language.getStringByParam(43526, marryApply.applicator.name), null, Alert.OK | Alert.CANCEL, null, onChoose);
            return;
        }

        /* internal  */onMarryReplyCommandHandler(arg1: SMarryReply): void
        {
            var loc1=Language.getString(43527);
            if (arg1.result == EMarryReplyResult._EMarryReplyResultReject) 
            {
                loc1 = Language.getString(43528);
            }
            MsgManager.showRollTipsMsg(loc1);
            return;
        }

        /* internal  */onRegistSuccessHandler(arg1: SWedding): void
        {
            this.marryRegister.updateMarryMsg(arg1);
            this.marryRegister.show();
            return;
        }

        /* internal  */onBookHoursHandler(arg1: Array<any>): void
        {
            this.marryBookingScene.updateBookHours(arg1);
            return;
        }

        /* internal  */onBookingSceneSuccessHandler(arg1: SWedding): void
        {
            this.marryBookingSuccessWindow.updateData(arg1);
            this.marryBookingSuccessWindow.show();
            return;
        }

        /* internal  */onInvitedGuestUpdate(arg1: Array<any>): void
        {
            this.marryInviteGuests.updateInvitedGuest(arg1);
            return;
        }

        /* internal  */onMarryCanInviteNum(arg1: int): void
        {
            this.marryInviteGuests.updateCanInvitedNum(arg1);
            return;
        }

        /* internal  */onBlessHistoryHandler(arg1: Array<any>): void
        {
            this.marryBlessWindow.updateBlessHistory(arg1);
            return;
        }

        /* internal  */onMarryEndCeremonyHandler(arg1: Object): void
        {
            this._isOver = true;
            if (this._ceremonyPlayer) 
            {
                this._ceremonyPlayer.dispose();
                this._ceremonyPlayer = null;
            }
            MsgManager.showTaskTarget(Language.getString(43599));
            RolePlayer.instance.addToLayer();
            return;
        }

        /* internal  */onParadeStartCommandHandler(arg1: Object): void
        {
            if (this._tipAlert && this._tipAlert.parent) 
            {
                this._tipAlert.parent.removeChild(this._tipAlert);
                this._tipAlert = null;
            }
            this.marryParadeIconView.show();
            if (!this._paradeTimer) 
            {
                this._paradeTimer = new SecTimer(1);
                this._paradeTimer.addListener(TimerType.ENTERFRAME, this.onParadeTime);
            }
            this._paradeTimer.start();
            return;
        }

        public resetPosition(): void
        {
            if (this._marryWeddingView) 
            {
                this.marryWeddingView.resetPosition();
            }
            return;
        }

        /* internal  */onParadeTime(arg1: SecTimer): void
        {
            var loc2=null;
            var loc3=null;
            var loc1=arg1.currentCount;
            var loc6=0;
            var loc7=ThingUtil.entityUtil.allEntitys;
            for(loc3 of loc7) 
            {
                if (typeof !(loc3 === "monsterplayer")) 
                {
                    continue;
                }
                loc2 = loc3 as MonsterPlayer;
                if (loc2.bossType != EBossType._EBossTypeMarch) 
                {
                    continue;
                }
                break;
            }
            if (!loc2 || !cache.scene.isSceneByCamp(4, 1)) 
            {
                return;
            }
            var loc4=new Object /* flash.geom.Point */(loc2.x, loc2.y);
            var loc5=loc2.tboss.level;
            FWManager.instance.popup(1, 0, loc4, FireWorkType.MarryFire1, "", FirePlayType.TogetherPlay);
            if (loc5 < 15) 
            {
                return;
            }
            if ((loc1 - 1) % 2 == 0) 
            {
                FWManager.instance.popup(1, 1, loc4, FireWorkType.MarryFire2, "", FirePlayType.TogetherPlay);
            }
            if (loc5 < 25) 
            {
                return;
            }
            if (loc1 % 3 == 0) 
            {
                FWManager.instance.popup(1, 2, loc4, FireWorkType.MarryFire3, "", FirePlayType.TogetherPlay);
            }
            return;
        }

        /* internal  */onParadeEndCommandHandler(arg1: Object): void
        {
            this.marryParadeIconView.hide();
            if (this._paradeTimer) 
            {
                this._paradeTimer.stop();
                this._paradeTimer.dispose();
            }
            return;
        }

        /* internal  */onCelebrationStartCommandHandler(arg1: SWedding): void
        {
            this.marryCelebrationIconView.show();
            var loc1=arg1.weddingDt;
            var loc2=ClockManager.instance.nowDate;
            var loc3=(loc1.time + GameConst.WeddingCopyLifeTime * 1000 - loc2.time) / 1000;
            this.marryCelebrationIconView.updateLeftTime(loc3);
            if (cache.copy.isInWeddingCopy()) 
            {
                this.updateMarryWeddingScene();
            }
            return;
        }

        /* internal  */onCelebrationEndCommandHandler(arg1: Object): void
        {
            this.marryCelebrationIconView.hide();
            return;
        }

        /* internal  */onGuestInfosCommandHandler(arg1: SMarryGuestInfos): void
        {
            this.marryManageWindow.updateSceneGuestInfos(arg1);
            return;
        }

        public get isRequestWeddingShop(): Boolean
        {
            return this._isRequestWeddingShop;
        }

        /* internal  */onCeremonyHandler(arg1: SMarryCeremony): void
        {
            if (!Game.scene.isInitialize) 
            {
                cache.marry.marryCeremony = arg1;
                return;
            }
            if (Cache.instance.marry.celebrationWedding && Cache.instance.copy.isInWeddingCopy()) 
            {
                var loc11=Cache.instance.marry.celebrationWedding.weddingType;
                switch (loc11) 
                {
                    case EMarryWeddingType._EMarryWeddingTypeSimple:
                    {
                        FlowerManager.instance.addFlowerQueue(9, 10000);
                        break;
                    }
                    case EMarryWeddingType._EMarryWeddingTypeNormal:
                    {
                        FlowerManager.instance.addFlowerQueue(9, 10000);
                        break;
                    }
                    case EMarryWeddingType._EMarryWeddingTypeAdvanced:
                    {
                        FlowerManager.instance.addFlowerQueue(99, 10000);
                        break;
                    }
                    case EMarryWeddingType._EMarryWeddingTypeLuxury:
                    {
                        FlowerManager.instance.addFlowerQueue(999, 15000);
                        break;
                    }
                }
            }
            this._isOver = false;
            var loc1=cache.role.entityInfo.name;
            if (arg1.man.name == loc1 || arg1.woman.name == loc1) 
            {
                RolePlayer.instance.removeToLayer();
            }
            var loc2=RolePlayer.instance.sex;
            var loc3=-1;
            if (cache.marry.playerMarry) 
            {
                loc3 = cache.marry.playerMarry.mate.sex;
            }
            var loc4=StaticResUrl.marryID;
            if (arg1.man.sex == arg1.woman.sex) 
            {
                if (arg1.man.sex != ESex._ESexMan) 
                {
                    if (arg1.man.sex == ESex._ESexWoman) 
                    {
                        loc4 = StaticResUrl.marryTwoWomanID;
                    }
                }
                else 
                {
                    loc4 = StaticResUrl.marryTwoManID;
                }
            }
            if (!this._ceremonyPlayer) 
            {
                this._ceremonyPlayer = new CeremonySprite();
                this._ceremonyPlayer.loadRes(loc4);
            }
            this._ceremonyPlayer.ceremonyStart();
            this._ceremonyPlayer.setMiniPlayer(arg1.man, arg1.woman);
            var loc5=GameMapUtil.getPixelPoint(arg1.ceremonyPoint.x, arg1.ceremonyPoint.y);
            var loc6=Game.scene.playerLayer;
            var loc7=Game.scene.skillsLayer;
            loc5 = loc6.localToGlobal(loc5);
            loc5 = loc7.globalToLocal(loc5);
            Game.scene.skillsLayer.fireEffect(this._ceremonyPlayer, loc5.x + loc6.x, loc5.y + loc6.y);
            var loc8=arg1.ceremonyDt;
            var loc9=ClockManager.instance.nowDate;
            var loc10=0;
            if (loc9.time > loc8.time) 
            {
                loc10 = loc9.time - loc8.time;
            }
            this.setAction(this._ceremonyPlayer, 32000, 1, loc10);
            this.setAction(this._ceremonyPlayer, 38000, 2, loc10);
            this.setAction(this._ceremonyPlayer, 44000, 3, loc10);
            this.setTalk(this._ceremonyPlayer, 19000, Language.getString(43529), 1, loc10);
            this.setTalk(this._ceremonyPlayer, 25000, Language.getString(43529), 2, loc10);
            this.setTalk(this._ceremonyPlayer, 21000, "", 1, loc10);
            this.setTalk(this._ceremonyPlayer, 27000, "", 2, loc10);
            return;
        }

        /* internal  */setAction(arg1: CeremonySprite, arg2: int, arg3: int, arg4: int): void
        {
            var ceremonyPlayer: CeremonySprite;
            var timeOut: int;
            var action: int;
            var timeDif: int;
            var timer: SecTimer;
            var onComplete: Function;

            var loc1;
            timer = null;
            ceremonyPlayer = arg1;
            timeOut = arg2;
            action = arg3;
            timeDif = arg4;
            if (timeOut > timeDif) 
            {
                onComplete = (arg1: SecTimer): void
                {
                    doAction(ceremonyPlayer, action);
                    timer.reset();
                    timer.stop();
                    return;
                }
                timer = new SecTimer((timeOut - timeDif) / 1000, 1);
                timer.addListener(TimerType.COMPLETE, onComplete);
                timer.start();
            }
            return;
        }

        /* internal  */doAction(arg1: CeremonySprite, arg2: int): void
        {
            if (this._isOver || !arg1) 
            {
                return;
            }
            var loc1=arg2;
            switch (loc1) 
            {
                case 1:
                {
                    arg1.ceremony1();
                    break;
                }
                case 2:
                {
                    arg1.ceremony2();
                    break;
                }
                case 3:
                {
                    arg1.ceremony3();
                    break;
                }
            }
            return;
        }

        /* internal  */setTalk(arg1: CeremonySprite, arg2: int, arg3: string, arg4: int, arg5: int): void
        {
            var ceremonyPlayer: CeremonySprite;
            var timeOut: int;
            var text: string;
            var action: int;
            var timeDif: int;
            var timer: SecTimer;
            var onComplete: Function;

            var loc1;
            timer = null;
            ceremonyPlayer = arg1;
            timeOut = arg2;
            text = arg3;
            action = arg4;
            timeDif = arg5;
            if (timeOut > timeDif) 
            {
                onComplete = (arg1: SecTimer): void
                {
                    doTalk(ceremonyPlayer, text, action);
                    timer.reset();
                    timer.stop();
                    return;
                }
                timer = new SecTimer((timeOut - timeDif) / 1000, 1);
                timer.addListener(TimerType.COMPLETE, onComplete);
                timer.start();
            }
            return;
        }

        /* internal  */doTalk(arg1: CeremonySprite, arg2: string, arg3: int): void
        {
            if (this._isOver || !arg1) 
            {
                return;
            }
            var loc1=arg3;
            switch (loc1) 
            {
                case 1:
                {
                    arg1.manTalk(arg2);
                    break;
                }
                case 2:
                {
                    arg1.womenTalk(arg2);
                    break;
                }
            }
            return;
        }

        public set isRequestWeddingShop(arg1: Boolean)
        {
            this._isRequestWeddingShop = arg1;
            return;
        }

        /* internal  */updateMarryWeddingScene(): void
        {
            if (!cache.marry.celebrationWedding || this._isInitMarryWeddingScene) 
            {
                return;
            }
            var loc2=cache.marry.celebrationWedding.weddingType;
            switch (loc2) 
            {
                case EMarryWeddingType._EMarryWeddingTypeNormal:
                {
                    MarryFlowerManager.instance.addFlowerQueue(MarryFlowerType.FLOWER_2, 3600000);
                    break;
                }
                case EMarryWeddingType._EMarryWeddingTypeAdvanced:
                {
                    MarryFlowerManager.instance.addFlowerQueue(MarryFlowerType.FLOWER_3, 36000000);
                    MarrySceneFire.startSceneFire(3);
                    break;
                }
                case EMarryWeddingType._EMarryWeddingTypeLuxury:
                {
                    MarryFlowerManager.instance.addFlowerQueue(MarryFlowerType.FLOWER_4, 36000000);
                    MarrySceneFire.startSceneFire(4);
                    break;
                }
            }
            this.marryWeddingView.show();
            this.marryWeddingView.updateWeddingMsg(cache.marry.celebrationWedding, cache.marry.isHadStartCeremony);
            var loc1=GameConst.WeddingMaxSweet;
            if (cache.marry.weddingFireWork) 
            {
                this.marryWeddingView.updateSweet(cache.marry.weddingFireWork.sweetDegree, loc1);
            }
            else 
            {
                this.marryWeddingView.updateSweet(0, loc1);
            }
            this._isInitMarryWeddingScene = true;
            return;
        }

        /* internal  */onMarryHistoryDataHandler(arg1: MarryHistoryData): void
        {
            this.marryLogWindow.updateLog(arg1);
            return;
        }

        /* internal  */onMarryInviteInfoHandler(arg1: SWeddingGuestInfo): void
        {
            if (this._marryInviteGuests) 
            {
                this.marryInviteGuests.updateCanInvitedNum(arg1.canInviteGuestNum);
                this.marryInviteGuests.updateCanUseInviteCardNum(arg1.canUseInviteCardNum);
            }
            return;
        }

        /* internal  */onMarryWeddingApplicatorsHandler(arg1: SWeddingApplicators): void
        {
            if (this._marryManageWindow) 
            {
                this.marryManageWindow.updateApplicators(arg1);
            }
            return;
        }

        /* internal  */onWeddingCanEnterHandler(arg1: SWedding): void
        {
            this.marryMsgWindow.updateWedding(arg1);
            this.marryMsgWindow.show();
            return;
        }

        /* internal  */onMarryWeddingStatusHandler(arg1: SWeddingStatus): void
        {
            var loc1=0;
            var loc2=0;
            var loc3=0;
            var loc4=null;
            var loc5=null;
            if (!arg1) 
            {
                return;
            }
            if (arg1.status == EWeddingStatus._EWeddingStatusHadBooked) 
            {
                if (!MarryController._isTip) 
                {
                    loc1 = ClockManager.instance.nowDate.time;
                    loc2 = arg1.bookDt.time;
                    loc3 = loc2 - (10 * 60 - 5) * 1000;
                    if (loc1 < loc2) 
                    {
                        if (loc1 > loc3) 
                        {
                            this.tip();
                        }
                        else 
                        {
                            this._tipTimer = new SecTimer((loc3 - loc1) / 1000, 1);
                            this._tipTimer.addListener(TimerType.COMPLETE, this.onTimeComplete);
                            this._tipTimer.start();
                        }
                    }
                }
            }
            if (arg1.status == EWeddingStatus._EWeddingStatusHadBooked || arg1.status == EWeddingStatus._EWeddingStatusWeddingCar) 
            {
                loc4 = ClockManager.instance.nowDate;
                loc5 = arg1.bookDt;
                if (loc4.time < loc5.time) 
                {
                    this.marryProcessIconView.show();
                    this.marryProcessIconView.updateLeftTime(int((loc5.time - loc4.time) / 1000));
                }
                else if (this._marryProcessIconView) 
                {
                    this.marryProcessIconView.hide();
                }
            }
            else if (this._marryProcessIconView) 
            {
                this.marryProcessIconView.hide();
            }
            return;
        }

        /* internal  */onTimeComplete(arg1: SecTimer): void
        {
            this.clearWeddingCarTips();
            this.tip();
            return;
        }

        /* internal  */clearWeddingCarTips(): void
        {
            if (this._tipTimer) 
            {
                this._tipTimer.stop();
                this._tipTimer.dispose();
                this._tipTimer = null;
            }
            return;
        }

        /* internal  */tip(): void
        {
            if (MarryController._isTip) 
            {
                return;
            }
            MarryController._isTip = true;
            Alert.okLabel = Language.getString(43503);
            Alert.calcelLabel = Language.getString(43504);
            Alert.buttonWidth = 70;
            this._tipAlert = Alert.show(Language.getString(43505), null, Alert.OK | Alert.CANCEL, null, this.onChoose);
            return;
        }

        /* internal  */onChoose(arg1: int): void
        {
            if (arg1 == Alert.OK) 
            {
                AIManager.onAutoPathAIControl(Cache.instance.scene.getNpcByEffect(ENpcEffect._ENpcEffectMarryRegister));
            }
            return;
        }

        /* internal  */onMarrySearchPlayerSuccessHandler(arg1: string): void
        {
            this.marryInviteGuests.addPeople(arg1);
            return;
        }

        /* internal  */onMarryEnterWeddingHandler(arg1: Object): void
        {
            if (this._marryMsgWindow) 
            {
                this._marryMsgWindow.hide();
            }
            this.updateMarryWeddingScene();
            return;
        }

        /* internal  */onMarryLeaveWeddingHandler(arg1: Object): void
        {
            MarryFlowerManager.instance.stop();
            this.marryWeddingView.hide();
            this._isInitMarryWeddingScene = false;
            MarrySceneFire.removeSceneFire();
            return;
        }

        /* internal  */onMarryCeremoneyHadStartHandler(arg1: Object): void
        {
            this.marryWeddingView.updateWeddingMsg(cache.marry.celebrationWedding, true);
            return;
        }

        /* internal  */onMarryWeddingFireWorkHandler(arg1: SWeddingFirework): void
        {
            var loc1=GameConst.WeddingMaxSweet;
            if (this._marryWeddingView) 
            {
                this._marryWeddingView.updateSweet(arg1.sweetDegree, loc1);
            }
            return;
        }

        /* internal  */onMarryPlayerMarryUpdateHandler(arg1: SPlayerMarry): void
        {
            var loc1=0;
            if (this.isDivorceStatus(this._lastPlayerMarry)) 
            {
                if (arg1.status == EMarryStatus._EMarryStatusNo || arg1.status == EMarryStatus._EMarryStatusYes) 
                {
                    if (arg1.status == EMarryStatus._EMarryStatusNo) 
                    {
                        cache.marry.weddingStatus = null;
                    }
                    this.marryDivorceIconView.hide();
                    this.clearWeddingCarTips();
                    if (this._marryProcessIconView) 
                    {
                        this.marryProcessIconView.hide();
                    }
                }
            }
            if (this.isDivorceStatus(arg1)) 
            {
                this.marryDivorceIconView.show();
                loc1 = 72 * 3600 - int((ClockManager.instance.nowDate.time - arg1.divorceApplyDt.time) / 1000);
                if (loc1 > 0) 
                {
                    this.marryDivorceIconView.updateLeftTime(loc1);
                }
            }
            this._lastPlayerMarry = arg1;
            return;
        }

        /* internal  */onMarryApplyDivorceSuccessHandler(arg1: Object): void
        {
            if (this._marryDivorce) 
            {
                this.marryDivorce.hide();
            }
            return;
        }

        /* internal  */isDivorceStatus(arg1: SPlayerMarry): Boolean
        {
            return arg1 && (arg1.status == EMarryStatus._EMarryStatusApply || arg1.status == EMarryStatus._EMarryStatusBeApply);
        }

        /* internal  */onMarryHasWeddingApplyHandler(arg1: Object): void
        {
            if (this._marryCelebrationIconView && (!this._marryMsgWindow || this.marryMsgWindow.isHide)) 
            {
                this.marryCelebrationIconView.flicker();
            }
            return;
        }

        /* internal  */onMarryPackInvitesUpdateHandler(arg1: Object): void
        {
            if (this._marryInviteGuests) 
            {
                this.marryInviteGuests.beginInvite();
            }
            return;
        }

        /* internal  */onFriendListUpdate(arg1: Object): void
        {
            if (this._marryInviteGuests) 
            {
                this._marryInviteGuests.updateFriends();
            }
            return;
        }

        /* internal  */onActiveTypeMarrySameSexHandler(arg1: SActiveToClient): void
        {
            this._isInMarrySameSexActive = cache.active.isActiveInEffectByInfo(arg1);
            return;
        }

        /* internal  */getSexType(): int
        {
            var loc1=-1;
            if (this._isInMarrySameSexActive) 
            {
                if (cache.marry.playerMarry && cache.marry.playerMarry.mate.sex == cache.role.entityInfo.sex) 
                {
                    loc1 = cache.role.entityInfo.sex;
                }
            }
            return loc1;
        }

        /* internal  */get marryBookingScene(): MarryBookingScene
        {
            if (!this._marryBookingScene) 
            {
                this._marryBookingScene = new MarryBookingScene();
            }
            this._marryBookingScene.sexType = this.getSexType();
            return this._marryBookingScene;
        }

        public get marryInviteGuests(): MarryInviteGuests
        {
            if (!this._marryInviteGuests) 
            {
                this._marryInviteGuests = new MarryInviteGuests();
            }
            return this._marryInviteGuests;
        }

        public get marryManageWindow(): MarryManageWindow
        {
            if (!this._marryManageWindow) 
            {
                this._marryManageWindow = new MarryManageWindow();
            }
            return this._marryManageWindow;
        }

        /* internal  */get marryDivorce(): MarryDivorce
        {
            if (!this._marryDivorce) 
            {
                this._marryDivorce = new MarryDivorce();
            }
            return this._marryDivorce;
        }

        /* internal  */get marryBlessWindow(): MarryBlessWindow
        {
            if (!this._marryBlessWindow) 
            {
                this._marryBlessWindow = new MarryBlessWindow();
            }
            return this._marryBlessWindow;
        }

        /* internal  */get marryMsgWindow(): MarryMsgWindow
        {
            if (!this._marryMsgWindow) 
            {
                this._marryMsgWindow = new MarryMsgWindow();
            }
            return this._marryMsgWindow;
        }

        /* internal  */get marryParadeIconView(): MarryParadeIconView
        {
            if (!this._marryParadeIconView) 
            {
                this._marryParadeIconView = new MarryParadeIconView();
            }
            return this._marryParadeIconView;
        }

        /* internal  */get marryCelebrationIconView(): MarryCelebrationIconView
        {
            if (!this._marryCelebrationIconView) 
            {
                this._marryCelebrationIconView = new MarryCelebrationIconView();
            }
            return this._marryCelebrationIconView;
        }

        /* internal  */get marryProcessIconView(): MarryProcessIconView
        {
            if (!this._marryProcessIconView) 
            {
                this._marryProcessIconView = new MarryProcessIconView();
            }
            return this._marryProcessIconView;
        }

        /* internal  */get marryRegister(): MarryRegister
        {
            if (!this._marryRegister) 
            {
                this._marryRegister = new MarryRegister();
            }
            return this._marryRegister;
        }

        
        {
            MarryController._isTip = false;
        }

        /* internal  */get marryBookingSuccessWindow(): MarryBookingSuccessWindow
        {
            if (!this._marryBookingSuccessWindow) 
            {
                this._marryBookingSuccessWindow = new MarryBookingSuccessWindow();
            }
            return this._marryBookingSuccessWindow;
        }

        /* internal  */get marryLogWindow(): MarryLog
        {
            if (!this._marryLogWindow) 
            {
                this._marryLogWindow = new MarryLog();
            }
            return this._marryLogWindow;
        }

        /* internal  */get marryProcessWindow(): MarryProcess
        {
            if (!this._marryProcessWindow) 
            {
                this._marryProcessWindow = new MarryProcess();
            }
            return this._marryProcessWindow;
        }

        private /* var */_isRequestWeddingShop: Boolean=false;

        private /* var */_isInMarrySameSexActive: Boolean=false;

        private /* var */aryPoint: Array<any>;

        private /* var */_ceremonyPlayer: CeremonySprite;

        private /* var */_isOver: Boolean=false;

        private /* var */_marryProcessIconView: MarryProcessIconView;

        private /* var */_lastPlayerMarry: SPlayerMarry;

        private /* var */_marryRegister: MarryRegister;

        private /* var */_paradeTimer: SecTimer;

        private /* var */_marryManageWindow: MarryManageWindow;

        private /* var */_tipAlert: Object /* flash.display.Sprite */;

        private /* var */_marryBookingSuccessWindow: MarryBookingSuccessWindow;

        private /* var */_marryBlessWindow: MarryBlessWindow;

        private /* var */_marryLogWindow: MarryLog;

        private /* var */_tipTimer: SecTimer;

        private /* var */_marryProcessWindow: MarryProcess;

        private /* var */_marryMsgWindow: MarryMsgWindow;

        private /* var */_marryWeddingView: MarryWeddingView;

        private /* var */_marryBookingScene: MarryBookingScene;

        private /* var */_marryDivorceIconView: MarryDivorceIconView;

        private /* var */_marryParadeIconView: MarryParadeIconView;

        private /* var */_isInitMarryWeddingScene: Boolean=false;

        private /* var */_marryCelebrationIconView: MarryCelebrationIconView;

        private /* var */_marryInviteGuests: MarryInviteGuests;

        private static /* var */_isTip: Boolean=false;

        private /* var */_marryDivorce: MarryDivorce;
    }
